home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / macmodule.c < prev    next >
Text File  |  1996-03-06  |  11KB  |  601 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Mac module implementation */
  26.  
  27. #include "allobjects.h"
  28. #include "modsupport.h"
  29. #include "ceval.h"
  30.  
  31. #include <stdio.h>
  32. #include <string.h>
  33. #include <errno.h>
  34.  
  35. #ifdef THINK_C
  36. #include "unix.h"
  37. #undef S_IFMT
  38. #undef S_IFDIR
  39. #undef S_IFCHR
  40. #undef S_IFBLK
  41. #undef S_IFREG
  42. #undef S_ISDIR
  43. #undef S_ISREG
  44. #endif
  45.  
  46. #ifdef USE_GUSI
  47. #include <GUSI.h>
  48. #include <sys/types.h>
  49. #include <stat.h>
  50. #define macstat stat
  51. #else
  52. #include "macstat.h"
  53. #endif
  54.  
  55. #ifdef __MWERKS__
  56. #include <unix.h>
  57. #else
  58. #include <fcntl.h>
  59. #endif
  60.  
  61. /* Optional routines, for some compiler/runtime combinations */
  62. #if defined(__MWERKS__) && defined(__powerc)
  63. #define MALLOC_DEBUG
  64. #endif
  65. #if defined(USE_GUSI) || !defined(__MWERKS__)
  66. #define WEHAVE_FDOPEN
  67. #endif
  68. #if defined(MPW) || defined(USE_GUSI)
  69. #define WEHAVE_DUP
  70. #endif
  71.  
  72. #include "macdefs.h"
  73. #ifdef USE_GUSI
  74. #include <dirent.h>
  75. #else
  76. #include "dirent.h"
  77. #endif
  78.  
  79. #ifndef MAXPATHLEN
  80. #define MAXPATHLEN 1024
  81. #endif
  82.  
  83. /* Prototypes for Unix simulation on Mac */
  84.  
  85. #ifndef USE_GUSI
  86.  
  87. int chdir PROTO((const char *path));
  88. int mkdir PROTO((const char *path, int mode));
  89. DIR * opendir PROTO((char *));
  90. void closedir PROTO((DIR *));
  91. struct dirent * readdir PROTO((DIR *));
  92. int rmdir PROTO((const char *path));
  93. int sync PROTO((void));
  94.  
  95. #if defined(THINK_C) || defined(__SC__)
  96. int unlink PROTO((char *));
  97. #else
  98. int unlink PROTO((const char *));
  99. #endif
  100.  
  101. #endif /* USE_GUSI */
  102.  
  103. char *getwd PROTO((char *));
  104. char *getbootvol PROTO((void));
  105.  
  106.  
  107. static object *MacError; /* Exception mac.error */
  108.  
  109. /* Set a MAC-specific error from errno, and return NULL */
  110.  
  111. static object * 
  112. mac_error() 
  113. {
  114.     return err_errno(MacError);
  115. }
  116.  
  117. /* MAC generic methods */
  118.  
  119. static object *
  120. mac_1str(args, func)
  121.     object *args;
  122.     int (*func) FPROTO((const char *));
  123. {
  124.     char *path1;
  125.     int res;
  126.     if (!getargs(args, "s", &path1))
  127.         return NULL;
  128.     BGN_SAVE
  129.     res = (*func)(path1);
  130.     END_SAVE
  131.     if (res < 0)
  132.         return mac_error();
  133.     INCREF(None);
  134.     return None;
  135. }
  136.  
  137. static object *
  138. mac_2str(args, func)
  139.     object *args;
  140.     int (*func) FPROTO((const char *, const char *));
  141. {
  142.     char *path1, *path2;
  143.     int res;
  144.     if (!getargs(args, "(ss)", &path1, &path2))
  145.         return NULL;
  146.     BGN_SAVE
  147.     res = (*func)(path1, path2);
  148.     END_SAVE
  149.     if (res < 0)
  150.         return mac_error();
  151.     INCREF(None);
  152.     return None;
  153. }
  154.  
  155. static object *
  156. mac_strint(args, func)
  157.     object *args;
  158.     int (*func) FPROTO((const char *, int));
  159. {
  160.     char *path;
  161.     int i;
  162.     int res;
  163.     if (!getargs(args, "(si)", &path, &i))
  164.         return NULL;
  165.     BGN_SAVE
  166.     res = (*func)(path, i);
  167.     END_SAVE
  168.     if (res < 0)
  169.         return mac_error();
  170.     INCREF(None);
  171.     return None;
  172. }
  173.  
  174. static object *
  175. mac_chdir(self, args)
  176.     object *self;
  177.     object *args;
  178. {
  179. #ifdef USE_GUSI
  180.     object *rv;
  181.     
  182.     /* Change MacOS's idea of wd too */
  183.     rv = mac_1str(args, chdir);
  184.     PyMac_FixGUSIcd();
  185.     return rv;
  186. #else
  187.     return mac_1str(args, chdir);
  188. #endif
  189.  
  190. }
  191.  
  192. static object *
  193. mac_close(self, args)
  194.     object *self;
  195.     object *args;
  196. {
  197.     int fd, res;
  198.     if (!getargs(args, "i", &fd))
  199.         return NULL;
  200.     BGN_SAVE
  201.     res = close(fd);
  202.     END_SAVE
  203. #ifndef USE_GUSI
  204.     /* GUSI gives surious errors here? */
  205.     if (res < 0)
  206.         return mac_error();
  207. #endif
  208.     INCREF(None);
  209.     return None;
  210. }
  211.  
  212. #ifdef WEHAVE_DUP
  213.  
  214. static object *
  215. mac_dup(self, args)
  216.     object *self;
  217.     object *args;
  218. {
  219.     int fd;
  220.     if (!getargs(args, "i", &fd))
  221.         return NULL;
  222.     BGN_SAVE
  223.     fd = dup(fd);
  224.     END_SAVE
  225.     if (fd < 0)
  226.         return mac_error();
  227.     return newintobject((long)fd);
  228. }
  229.  
  230. #endif
  231.  
  232. #ifdef WEHAVE_FDOPEN
  233. static object *
  234. mac_fdopen(self, args)
  235.     object *self;
  236.     object *args;
  237. {
  238.     extern int fclose PROTO((FILE *));
  239.     int fd;
  240.     char *mode;
  241.     FILE *fp;
  242.     if (!getargs(args, "(is)", &fd, &mode))
  243.         return NULL;
  244.     BGN_SAVE
  245.     fp = fdopen(fd, mode);
  246.     END_SAVE
  247.     if (fp == NULL)
  248.         return mac_error();
  249.     return newopenfileobject(fp, "(fdopen)", mode, fclose);
  250. }
  251. #endif
  252.  
  253. static object *
  254. mac_getbootvol(self, args)
  255.     object *self;
  256.     object *args;
  257. {
  258.     char *res;
  259.     if (!getnoarg(args))
  260.         return NULL;
  261.     BGN_SAVE
  262.     res = getbootvol();
  263.     END_SAVE
  264.     if (res == NULL)
  265.         return mac_error();
  266.     return newstringobject(res);
  267. }
  268.  
  269. static object *
  270. mac_getcwd(self, args)
  271.     object *self;
  272.     object *args;
  273. {
  274.     char path[MAXPATHLEN];
  275.     char *res;
  276.     if (!getnoarg(args))
  277.         return NULL;
  278.     BGN_SAVE
  279. #ifdef USE_GUSI
  280.     res = getcwd(path, sizeof path);
  281. #else
  282.     res = getwd(path);
  283. #endif
  284.     END_SAVE
  285.     if (res == NULL) {
  286.         err_setstr(MacError, path);
  287.         return NULL;
  288.     }
  289.     return newstringobject(res);
  290. }
  291.  
  292. static object *
  293. mac_listdir(self, args)
  294.     object *self;
  295.     object *args;
  296. {
  297.     char *name;
  298.     object *d, *v;
  299.     DIR *dirp;
  300.     struct dirent *ep;
  301.     if (!getargs(args, "s", &name))
  302.         return NULL;
  303.     BGN_SAVE
  304.     if ((dirp = opendir(name)) == NULL) {
  305.         RET_SAVE
  306.         return mac_error();
  307.     }
  308.     if ((d = newlistobject(0)) == NULL) {
  309.         closedir(dirp);
  310.         RET_SAVE
  311.         return NULL;
  312.     }
  313.     while ((ep = readdir(dirp)) != NULL) {
  314.         v = newstringobject(ep->d_name);
  315.         if (v == NULL) {
  316.             DECREF(d);
  317.             d = NULL;
  318.             break;
  319.         }
  320.         if (addlistitem(d, v) != 0) {
  321.             DECREF(v);
  322.             DECREF(d);
  323.             d = NULL;
  324.             break;
  325.         }
  326.         DECREF(v);
  327.     }
  328.     closedir(dirp);
  329.     END_SAVE
  330.  
  331.     return d;
  332. }
  333.  
  334. static object *
  335. mac_lseek(self, args)
  336.     object *self;
  337.     object *args;
  338. {
  339.     int fd;
  340.     int where;
  341.     int how;
  342.     long res;
  343.     if (!getargs(args, "(iii)", &fd, &where, &how))
  344.         return NULL;
  345.     BGN_SAVE
  346.     res = lseek(fd, (long)where, how);
  347.     END_SAVE
  348.     if (res < 0)
  349.         return mac_error();
  350.     return newintobject(res);
  351. }
  352.  
  353. static object *
  354. mac_mkdir(self, args)
  355.     object *self;
  356.     object *args;
  357. {
  358.     int res;
  359.     char *path;
  360.     int mode = 0777; /* Unused */
  361.     if (!newgetargs(args, "s|i", &path, &mode))
  362.         return NULL;
  363.     BGN_SAVE
  364.     res = mkdir(path, mode);
  365.     END_SAVE
  366.     if (res < 0)
  367.         return mac_error();
  368.     INCREF(None);
  369.     return None;
  370. }
  371.  
  372. static object *
  373. mac_open(self, args)
  374.     object *self;
  375.     object *args;
  376. {
  377.     char *path;
  378.     int mode;
  379.     int fd;
  380.     if (!getargs(args, "(si)", &path, &mode))
  381.         return NULL;
  382.     BGN_SAVE
  383.     fd = open(path, mode);
  384.     END_SAVE
  385.     if (fd < 0)
  386.         return mac_error();
  387.     return newintobject((long)fd);
  388. }
  389.  
  390. static object *
  391. mac_read(self, args)
  392.     object *self;
  393.     object *args;
  394. {
  395.     int fd, size;
  396.     object *buffer;
  397.     if (!getargs(args, "(ii)", &fd, &size))
  398.         return NULL;
  399.     buffer = newsizedstringobject((char *)NULL, size);
  400.     if (buffer == NULL)
  401.         return NULL;
  402.     BGN_SAVE
  403.     size = read(fd, getstringvalue(buffer), size);
  404.     END_SAVE
  405.     if (size < 0) {
  406.         DECREF(buffer);
  407.         return mac_error();
  408.     }
  409.     resizestring(&buffer, size);
  410.     return buffer;
  411. }
  412.  
  413. static object *
  414. mac_rename(self, args)
  415.     object *self;
  416.     object *args;
  417. {
  418.     return mac_2str(args, rename);
  419. }
  420.  
  421. static object *
  422. mac_rmdir(self, args)
  423.     object *self;
  424.     object *args;
  425. {
  426.     return mac_1str(args, rmdir);
  427. }
  428.  
  429. static object *
  430. mac_stat(self, args)
  431.     object *self;
  432.     object *args;
  433. {
  434.     struct macstat st;
  435.     char *path;
  436.     int res;
  437.     if (!getargs(args, "s", &path))
  438.         return NULL;
  439.     BGN_SAVE
  440.     res = macstat(path, &st);
  441.     END_SAVE
  442.     if (res != 0)
  443.         return mac_error();
  444.     return mkvalue("(llllllllll)",
  445.             (long)st.st_mode,
  446.             (long)st.st_ino,
  447.             (long)st.st_dev,
  448.             (long)st.st_nlink,
  449.             (long)st.st_uid,
  450.             (long)st.st_gid,
  451.             (long)st.st_size,
  452.             (long)st.st_atime,
  453.             (long)st.st_mtime,
  454.             (long)st.st_ctime);
  455. }
  456.  
  457. static object *
  458. mac_xstat(self, args)
  459.     object *self;
  460.     object *args;
  461. {
  462.     struct macstat st;
  463.     char *path;
  464.     int res;
  465.     if (!getargs(args, "s", &path))
  466.         return NULL;
  467.     BGN_SAVE
  468.     res = macstat(path, &st);
  469.     END_SAVE
  470.     if (res != 0)
  471.         return mac_error();
  472. #ifdef USE_GUSI
  473.     return mkvalue("(llllllllll)",
  474.             (long)st.st_mode,
  475.             (long)st.st_ino,
  476.             (long)st.st_dev,
  477.             (long)st.st_nlink,
  478.             (long)st.st_uid,
  479.             (long)st.st_gid,
  480.             (long)st.st_size,
  481.             (long)st.st_atime,
  482.             (long)st.st_mtime,
  483.             (long)st.st_ctime);
  484. #else
  485.     return mkvalue("(llllllllllls#s#)",
  486.             (long)st.st_mode,
  487.             (long)st.st_ino,
  488.             (long)st.st_dev,
  489.             (long)st.st_nlink,
  490.             (long)st.st_uid,
  491.             (long)st.st_gid,
  492.             (long)st.st_size,
  493.             (long)st.st_atime,
  494.             (long)st.st_mtime,
  495.             (long)st.st_ctime,
  496.             (long)st.st_rsize,
  497.             st.st_creator, 4,
  498.             st.st_type, 4);
  499. #endif
  500. }
  501.  
  502. static object *
  503. mac_sync(self, args)
  504.     object *self;
  505.     object *args;
  506. {
  507.     int res;
  508.     if (!getnoarg(args))
  509.         return NULL;
  510.     BGN_SAVE
  511.     res = sync();
  512.     END_SAVE
  513.     if (res != 0)
  514.         return mac_error();
  515.     INCREF(None);
  516.     return None;
  517. }
  518.  
  519. static object *
  520. mac_unlink(self, args)
  521.     object *self;
  522.     object *args;
  523. {
  524.     return mac_1str(args, (int (*)(const char *))unlink);
  525. }
  526.  
  527. static object *
  528. mac_write(self, args)
  529.     object *self;
  530.     object *args;
  531. {
  532.     int fd, size;
  533.     char *buffer;
  534.     if (!getargs(args, "(is#)", &fd, &buffer, &size))
  535.         return NULL;
  536.     BGN_SAVE
  537.     size = write(fd, buffer, size);
  538.     END_SAVE
  539.     if (size < 0)
  540.         return mac_error();
  541.     return newintobject((long)size);
  542. }
  543.  
  544. #ifdef MALLOC_DEBUG
  545. static object *
  546. mac_mstats(self, args)
  547.     object*self;
  548.     object *args;
  549. {
  550.     mstats("python");
  551.     INCREF(None);
  552.     return None;
  553. }
  554. #endif MALLOC_DEBUG
  555.  
  556. static struct methodlist mac_methods[] = {
  557.     {"chdir",    mac_chdir},
  558.     {"close",    mac_close},
  559. #ifdef WEHAVE_DUP
  560.     {"dup",        mac_dup},
  561. #endif
  562. #ifdef WEHAVE_FDOPEN
  563.     {"fdopen",    mac_fdopen},
  564. #endif
  565.     {"getbootvol",    mac_getbootvol}, /* non-standard */
  566.     {"getcwd",    mac_getcwd},
  567.     {"listdir",    mac_listdir, 0},
  568.     {"lseek",    mac_lseek},
  569.     {"mkdir",    mac_mkdir, 1},
  570.     {"open",    mac_open},
  571.     {"read",    mac_read},
  572.     {"rename",    mac_rename},
  573.     {"rmdir",    mac_rmdir},
  574.     {"stat",    mac_stat},
  575.     {"xstat",    mac_xstat},
  576.     {"sync",    mac_sync},
  577.     {"remove",    mac_unlink},
  578.     {"unlink",    mac_unlink},
  579.     {"write",    mac_write},
  580. #ifdef MALLOC_DEBUG
  581.     {"mstats",    mac_mstats},
  582. #endif
  583.  
  584.     {NULL,        NULL}         /* Sentinel */
  585. };
  586.  
  587.  
  588. void
  589. initmac()
  590. {
  591.     object *m, *d;
  592.     
  593.     m = initmodule("mac", mac_methods);
  594.     d = getmoduledict(m);
  595.     
  596.     /* Initialize mac.error exception */
  597.     MacError = newstringobject("mac.error");
  598.     if (MacError == NULL || dictinsert(d, "error", MacError) != 0)
  599.         fatal("can't define mac.error");
  600. }
  601.